import { reqCheckAllCart, reqDeleteCart, reqFindCartList, reqInsertCart, reqMergeLocalCart, reqUpdateCartSku } from '@/api/cart'
import { getNewCartGoods } from '@/api/goods'
import { Promise } from 'core-js'

// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  // 修改  deleteCart   asyncDeleteCart  skuId
  mutations: {
    // 更新列表
    setList (state, list) {
      state.list = list
    },
    // 全选影响小选状态
    checkEffectAll (state, selected) {
      state.list.forEach(item => {
        if (item.isEffective) {
          item.selected = selected
        }
      })
    },
    // 更新购物车
    updateCart (state, goods) {
      // 更新购物车信息
      const goodsObj = state.list.find(item => item.skuId === goods.skuId)

      // 更新部位null的商品
      for (const key in goods) {
        if (goods[key] !== null) {
          goodsObj[key] = goods[key]
        }
      }
    },
    // 购物车删除
    deleteCart (state, skuId) {
      // 根据 skuId 删除
      state.list = state.list.filter(item => item.skuId !== skuId)
    },
    // 加入购物车逻辑
    insertCart (state, goods) {
      console.log('添加购物车逻辑')
      const index = state.list.findIndex(item => item.skuId === goods.skuId)
      if (index === -1) {
        // 情况1：未添加过的商品(前追加)
        state.list = [goods, ...state.list]
      } else {
        // 情况2：已添加过的商品(数量累加)
        state.list[index].count += goods.count
      }
    }
  },
  // 异步
  // action 内部需要区分 已登录 和 未登录 两种情况
  actions: {

    // 合并本地购物车
    async asyncMergeLocalCart (store) {
      const cartList = store.state.list.map(item => {
        return {
          skuId: item.skuId,
          selected: item.selected,
          count: item.count
        }
      })
      // 合并成功后，从后端获取最新购物车列表替换本地，业务代码在 asyncUpdateCart 内
      await reqMergeLocalCart(cartList)
    },

    // 全选影响小选
    asyncCheckEffectAll (store, selected) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录状态
          // console.log('登录状态')
          // 有效商品映射出skuid
          const ids = store.getters.effectiveList.map(v => v.skuId)
          // 登陆后全选影响小选
          reqCheckAllCart({ selected, ids }).then(res => {
            // 更新数据
            store.dispatch('asyncUpdateCaet')
            resolve()
          })
        } else {
          // 未登录状态
          store.commit('checkEffectAll', selected)
          resolve()
        }
      })
    },
    // 更新商品单个信息
    asyncUpdateCartSingle (store, goods) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 情况1：已登录 - 调用接口
          // console.log('调用接口')
          // 登录后购物车商品数量小选修改更新
          reqUpdateCartSku(goods).then(res => {
            resolve()
          })
        } else {
          store.commit('updateCart', goods)
          resolve()
        }
      })
    },
    // 更新购物车
    asyncUpdateCaet (store) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 情况1：已登录 - 调用接口
          // console.log('调用接口')
          reqFindCartList().then(({ result }) => {
            store.commit('setList', result)
            resolve()
          })
        } else {
          const arr = []
          store.state.list.forEach(item => {
            // 更新请求
            arr.push(getNewCartGoods(item.skuId))
          })
          // console.log(arr)
          // arr数据结构[反回结果]
          Promise.all(arr).then((res) => {
            // console.log(res)
            // 遍历到跟新值 和下标
            res.forEach((item, index) => {
              // 为返回的每一个商品更新信息
              // console.log(222, item, index)
              store.commit('updateCart', {
                // skuId 用于查找商品
                skuId: store.state.list[index].skuId,
                // 待更新的信息
                ...item.result
              })
            })
          })
          resolve()
        }
      })
    },

    // 删除购物车
    asyncDeleteCart (store, skuId) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 情况1：已登录 - 调用接口
          // console.log('调用接口')
          // 登录状态删除
          reqDeleteCart([skuId]).then(res => {
            // 删除后更新
            store.dispatch('asyncUpdateCaet')
          })
        } else {
          // 情况2：未登录 - 操作本地数据
          // console.log('操作本地数据')
          store.commit('deleteCart', skuId)
          // 调用 resolve() 后，会运行 Promise 对象的 then() 内部代码
          resolve()
        }
      })
    },
    // 加入购物车逻辑
    asyncInertCart (store, goods) {
      return new Promise((resolve, reject) => {
        // console.log('asyncInertCart', store.rootState.user.profile.token)
        if (store.rootState.user.profile.token) {
          // 情况1：已登录 - 调用接口
          // console.log('调用接口')
          // 登录加入购物车
          const { skuId, count } = goods
          reqInsertCart({ skuId, count }).then(res => {
            store.dispatch('asyncUpdateCaet')
            resolve()
          })
        } else {
          // 情况2：未登录 - 操作本地数据
          // console.log('操作本地数据')
          store.commit('insertCart', goods)
          // 调用 resolve() 后，会运行 Promise 对象的 then() 内部代码
          resolve()
        }
      })
    }
  },
  // 计算属性
  getters: {
    // 已选的有效商品列表
    selectedList (state, getters) {
      return getters.effectiveList.filter(item => item.selected)
    },
    // 已选的数量
    selectedListTotal (store, getters) {
      return getters.selectedList.reduce((total, item) => total + item.count, 0)
    },
    // 已选的价格
    selectedListTotalPrice (store, getters) {
      return getters.selectedList.reduce((total, item) => total + item.count * item.nowPrice, 0).toFixed(2)
    },
    // 全选计算
    isAllEffectSelected (store, getters) {
      return getters.effectiveList.every(item => item.selected) && getters.effectiveList.length !== 0
    },
    // 计算有效商品列表 isEffective = true  filter
    effectiveList (state) {
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 有效商品总数量 把effctiveList中的每一项的count叠加起来
    effectiveTotal (state, getters) {
      // 方法一
      // let total = 0
      // getters.effectiveList.forEach(item => {
      //   total += item.count
      // })
      // return total
      // 方法二：使用 reduce 快速实现
      return getters.effectiveList.reduce((total, item) => { return total + item.count }, 0)
    },
    // 总金额  = 所有单项的钱数累加  单项的钱数 = 数量 * 单价
    effectiveTotalPrice (state, getters) {
      return getters.effectiveList.reduce((total, item) => { return total + item.count * item.nowPrice }, 0).toFixed(2)
    }
  }
}
